/*
    * Copyright (C) 2011 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.net;
  
  import static com.google.common.base.Preconditions.checkArgument;
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.base.Preconditions.checkState;
  
  import com.google.common.annotations.Beta;
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.base.Objects;
  import com.google.common.base.Strings;
  
  import java.io.Serializable;
  
  import javax.annotation.Nullable;
  import javax.annotation.concurrent.Immutable;
  
  /**
   * An immutable representation of a host and port.
   *
   * <p>Example usage:
   * <pre>
   * HostAndPort hp = HostAndPort.fromString("[2001:db8::1]")
   *     .withDefaultPort(80)
   *     .requireBracketsForIPv6();
   * hp.getHostText();  // returns "2001:db8::1"
   * hp.getPort();      // returns 80
   * hp.toString();     // returns "[2001:db8::1]:80"
   * </pre>
   *
   * <p>Here are some examples of recognized formats:
   * <ul>
   *   <li>example.com
   *   <li>example.com:80
   *   <li>192.0.2.1
   *   <li>192.0.2.1:80
   *   <li>[2001:db8::1]     - {@link #getHostText()} omits brackets
   *   <li>[2001:db8::1]:80  - {@link #getHostText()} omits brackets
   *   <li>2001:db8::1       - Use {@link #requireBracketsForIPv6()} to prohibit this
   * </ul>
   *
   * <p>Note that this is not an exhaustive list, because these methods are only
   * concerned with brackets, colons, and port numbers.  Full validation of the
   * host field (if desired) is the caller's responsibility.
   *
   * @author Paul Marks
   * @since 10.0
   */
  @Beta
  @Immutable
  @GwtCompatible
  public final class HostAndPort implements Serializable {
    /** Magic value indicating the absence of a port number. */
    private static final int NO_PORT = -1;
  
    /** Hostname, IPv4/IPv6 literal, or unvalidated nonsense. */
    private final String host;
  
    /** Validated port number in the range [0..65535], or NO_PORT */
    private final int port;
  
    /** True if the parsed host has colons, but no surrounding brackets. */
    private final boolean hasBracketlessColons;
  
    private HostAndPort(String host, int port, boolean hasBracketlessColons) {
      this.host = host;
      this.port = port;
      this.hasBracketlessColons = hasBracketlessColons;
    }
  
    /**
     * Returns the portion of this {@code HostAndPort} instance that should
     * represent the hostname or IPv4/IPv6 literal.
     *
     * <p>A successful parse does not imply any degree of sanity in this field.
     * For additional validation, see the {@link HostSpecifier} class.
     */
    public String getHostText() {
      return host;
    }
  
    /** Return true if this instance has a defined port. */
    public boolean hasPort() {
      return port >= 0;
   }
 
   /**
    * Get the current port number, failing if no port is defined.
    *
    * @return a validated port number, in the range [0..65535]
    * @throws IllegalStateException if no port is defined.  You can use
    *         {@link #withDefaultPort(int)} to prevent this from occurring.
    */
   public int getPort() {
     checkState(hasPort());
     return port;
   }
 
   /**
    * Returns the current port number, with a default if no port is defined.
    */
   public int getPortOrDefault(int defaultPort) {
     return hasPort() ? port : defaultPort;
   }
 
   /**
    * Build a HostAndPort instance from separate host and port values.
    *
    * <p>Note: Non-bracketed IPv6 literals are allowed.
    * Use {@link #requireBracketsForIPv6()} to prohibit these.
    *
    * @param host the host string to parse.  Must not contain a port number.
    * @param port a port number from [0..65535]
    * @return if parsing was successful, a populated HostAndPort object.
    * @throws IllegalArgumentException if {@code host} contains a port number,
    *     or {@code port} is out of range.
    */
   public static HostAndPort fromParts(String host, int port) {
     checkArgument(isValidPort(port), "Port out of range: %s", port);
     HostAndPort parsedHost = fromString(host);
     checkArgument(!parsedHost.hasPort(), "Host has a port: %s", host);
     return new HostAndPort(parsedHost.host, port, parsedHost.hasBracketlessColons);
   }
 
   /**
    * Build a HostAndPort instance from a host only.
    *
    * <p>Note: Non-bracketed IPv6 literals are allowed.
    * Use {@link #requireBracketsForIPv6()} to prohibit these.
    *
    * @param host the host-only string to parse.  Must not contain a port number.
    * @return if parsing was successful, a populated HostAndPort object.
    * @throws IllegalArgumentException if {@code host} contains a port number.
    * @since 17.0
    */
   public static HostAndPort fromHost(String host) {
     HostAndPort parsedHost = fromString(host);
     checkArgument(!parsedHost.hasPort(), "Host has a port: %s", host);
     return parsedHost;
   }
 
   /**
    * Split a freeform string into a host and port, without strict validation.
    *
    * Note that the host-only formats will leave the port field undefined.  You
    * can use {@link #withDefaultPort(int)} to patch in a default value.
    *
    * @param hostPortString the input string to parse.
    * @return if parsing was successful, a populated HostAndPort object.
    * @throws IllegalArgumentException if nothing meaningful could be parsed.
    */
   public static HostAndPort fromString(String hostPortString) {
     checkNotNull(hostPortString);
     String host;
     String portString = null;
     boolean hasBracketlessColons = false;
 
     if (hostPortString.startsWith("[")) {
       String[] hostAndPort = getHostAndPortFromBracketedHost(hostPortString);
       host = hostAndPort[0];
       portString = hostAndPort[1];
     } else {
       int colonPos = hostPortString.indexOf(':');
       if (colonPos >= 0 && hostPortString.indexOf(':', colonPos + 1) == -1) {
         // Exactly 1 colon.  Split into host:port.
         host = hostPortString.substring(0, colonPos);
         portString = hostPortString.substring(colonPos + 1);
       } else {
         // 0 or 2+ colons.  Bare hostname or IPv6 literal.
         host = hostPortString;
         hasBracketlessColons = (colonPos >= 0);
       }
     }
 
     int port = NO_PORT;
     if (!Strings.isNullOrEmpty(portString)) {
       // Try to parse the whole port string as a number.
       // JDK7 accepts leading plus signs. We don't want to.
       checkArgument(!portString.startsWith("+"), "Unparseable port number: %s", hostPortString);
       try {
         port = Integer.parseInt(portString);
       } catch (NumberFormatException e) {
         throw new IllegalArgumentException("Unparseable port number: " + hostPortString);
       }
       checkArgument(isValidPort(port), "Port number out of range: %s", hostPortString);
     }
 
     return new HostAndPort(host, port, hasBracketlessColons);
   }
 
   /**
    * Parses a bracketed host-port string, throwing IllegalArgumentException if parsing fails.
    *
    * @param hostPortString the full bracketed host-port specification. Post might not be specified.
    * @return an array with 2 strings: host and port, in that order.
    * @throws IllegalArgumentException if parsing the bracketed host-port string fails.
    */
   private static String[] getHostAndPortFromBracketedHost(String hostPortString) {
     int colonIndex = 0;
     int closeBracketIndex = 0;
     checkArgument(hostPortString.charAt(0) == '[',
         "Bracketed host-port string must start with a bracket: %s", hostPortString);
     colonIndex = hostPortString.indexOf(':');
     closeBracketIndex = hostPortString.lastIndexOf(']');
     checkArgument(colonIndex > -1 && closeBracketIndex > colonIndex,
         "Invalid bracketed host/port: %s", hostPortString);
 
     String host = hostPortString.substring(1, closeBracketIndex);
     if (closeBracketIndex + 1 == hostPortString.length()) {
       return new String[] { host, "" };
     } else {
       checkArgument(hostPortString.charAt(closeBracketIndex + 1) == ':',
           "Only a colon may follow a close bracket: %s", hostPortString);
       for (int i = closeBracketIndex + 2; i < hostPortString.length(); ++i) {
         checkArgument(Character.isDigit(hostPortString.charAt(i)),
             "Port must be numeric: %s", hostPortString);
       }
       return new String[] { host, hostPortString.substring(closeBracketIndex + 2) };
     }
   }
 
   /**
    * Provide a default port if the parsed string contained only a host.
    *
    * You can chain this after {@link #fromString(String)} to include a port in
    * case the port was omitted from the input string.  If a port was already
    * provided, then this method is a no-op.
    *
    * @param defaultPort a port number, from [0..65535]
    * @return a HostAndPort instance, guaranteed to have a defined port.
    */
   public HostAndPort withDefaultPort(int defaultPort) {
     checkArgument(isValidPort(defaultPort));
     if (hasPort() || port == defaultPort) {
       return this;
     }
     return new HostAndPort(host, defaultPort, hasBracketlessColons);
   }
 
   /**
    * Generate an error if the host might be a non-bracketed IPv6 literal.
    *
    * <p>URI formatting requires that IPv6 literals be surrounded by brackets,
    * like "[2001:db8::1]".  Chain this call after {@link #fromString(String)}
    * to increase the strictness of the parser, and disallow IPv6 literals
    * that don't contain these brackets.
    *
    * <p>Note that this parser identifies IPv6 literals solely based on the
    * presence of a colon.  To perform actual validation of IP addresses, see
    * the {@link InetAddresses#forString(String)} method.
    *
    * @return {@code this}, to enable chaining of calls.
    * @throws IllegalArgumentException if bracketless IPv6 is detected.
    */
   public HostAndPort requireBracketsForIPv6() {
     checkArgument(!hasBracketlessColons, "Possible bracketless IPv6 literal: %s", host);
     return this;
   }
 
   @Override
   public boolean equals(@Nullable Object other) {
     if (this == other) {
       return true;
     }
     if (other instanceof HostAndPort) {
       HostAndPort that = (HostAndPort) other;
       return Objects.equal(this.host, that.host)
           && this.port == that.port
           && this.hasBracketlessColons == that.hasBracketlessColons;
     }
     return false;
   }
 
   @Override
   public int hashCode() {
     return Objects.hashCode(host, port, hasBracketlessColons);
   }
 
   /** Rebuild the host:port string, including brackets if necessary. */
   @Override
   public String toString() {
     // "[]:12345" requires 8 extra bytes.
     StringBuilder builder = new StringBuilder(host.length() + 8);
     if (host.indexOf(':') >= 0) {
       builder.append('[').append(host).append(']');
     } else {
       builder.append(host);
     }
     if (hasPort()) {
       builder.append(':').append(port);
     }
     return builder.toString();
   }
 
   /** Return true for valid port numbers. */
   private static boolean isValidPort(int port) {
     return port >= 0 && port <= 65535;
   }
 
   private static final long serialVersionUID = 0;
 }